package demo1;

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
//        try {
//            Scanner scanner = new Scanner(System.in);
//            int n = scanner.nextInt();
//
//        }catch ()
    }

}
//不管抛不抛出异常，finally都要执行
//finally 一般用来关闭资源（数据库连接资源 网络连接）

//不要在finally中return数据，在finally当中返回数据，一定会被接收到。
//为什么finally之后的语句和finally的语句都会执行，还要finall？因为如果在前
// 面的语句有返回的话，后面的语句不执行，但是finally一定会执行
//throws 是声明异常
//throw是抛出异常


//首先执行try当中的代码
//如果try当中的代码出现异常，就会结束当前的代码，在catch语句中寻找匹配的异常处理
//无论是否找到匹配的异常处理，finally都会处理



//自定义异常类



//异常 ： 程序运行过程中出现的问题,
//抛出的异常就是一个类 ,异常有很多类
//常见的有 --》算数异常 空指针异常 数组越界异常 栈溢出
//stack voer flow 栈溢出网站

//类型转换异常
//克隆异常
class Person implements Cloneable{
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();

    }
}

class T{
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] array = {1,2,3};
        System.out.println(array[10]);
        //数组越界异常
        Person person = new Person();
        Person person1 = new Person();
        person1 = (Person) person.clone();
        //编译时异常 在编译时候就开始报错 --》语法错误不是异常
        //受查异常 编译时异常   可以抛出去 throw
        //非受查异常 运行时异常

        //没有分号 中文分号 没有花括号 --》语法错误
        //运行时异常  在运行时报错的异常

    }
    public static void func() {
        func();
    }

    public static void main1(String[] args) {
        int[] arr = null;
        arr[0] = 11;
        //nullpointerexception
        System.out.println("hahha");
        //抛出异常之后，后面的内容将不会被打印（在没有处理异常的时候，程序会直接崩溃）

    }

    public static void main8(String[] args) {
        try{

        }catch(Exception e) {
            //一劳永逸的做法？？？不是，这样子的做法不可取，当代码出现异常时，
            // 如果在调试，则完全不能知道到底是什么异常，只知道是异常
            //try当中存在多个异常的时候，从上到下执行，先遇到那个异常，就捕获那个异常
            //
        }
    }

    public static void main7(String[] args) {
        try{

        }catch(Exception e) {
            //exception是所有异常的父类，可以捕获到所有的异常，如果方法catch的第一行，
            // 那么后续的异常，没有任何的用处了。，所以此处报红提示，所以exception一
            // 定要是catch最后一个，对代码进行兜底
        }
//        catch(NullPointerException e) {
//            System.out.println("haha");

//        可以把父类异常放在最后，对异常进行兜底
//        }
    }

    public static void main6(String[] args) {
        try {

        }catch( ArithmeticException | NullPointerException e) {
            e.printStackTrace();
            System.out.println("hah");
        //可以一行写完所有异常catch，但是在调试时不能知道是那个异常
        }
    }

    public static void main4(String[] args) {
        try {

        }catch (NullPointerException e) {
            e.printStackTrace();
            System.out.println("空指针异常");
        }catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("栈溢出");
        }
//        catch(CloneNotSupportedException e) {
//            //对于受查异常来说，当try当中没有抛出异常的时候，
//            //catch当中检测不到就会报错
//            //编译时异常 只有try当中有，才能在catch当中
             // 但是编译时异常不用
//        }
    }
}

//异常的内部体系，异常就是类，存在继承关系 exception
//exception 异常 ereor 错误 都是继承于throwable
//错误  例：栈溢出  必须程序员出手排查代码 ，将错误解决掉
//异常  exception
//runtimeexception  继承自exception
//exception 没有说明就是受查时异常
// 运行时异常--》算数 空指针 异常
// 编译时异常 --》


//try    当中存放可能抛出异常的代码
//catch  括号当中异常的类型所定义的变量 花括号当中 可以对补做到的异常做处理
//

//

class Base {

    public static int test12() {
        try{
            int a = 10;
            return a;
        }finally {
            return 100;
        }

    }
    public static void main(String[] args) {
        int a = test12();
        System.out.println(a);
        //程序最后接收到的是finally的返回值，但是不建议在finally当中些写return
        //代码可读性不好（编译器会报警告，但是不会报错）

//        throws 声明一个异常
//        throw抛出一个异常
    }

    public static void main45(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int a = scanner.nextInt();


        } catch (NullPointerException e) {

        }
        //抛出异常 不抛出异常 没有捕捉到匹配的异常 finally都要执行
        //不管是否在try中抛出异常，finally当中的代码终将被执行
        //一般用于资源的回收
        //

    }
    public static void main2(String[] args) {
        //catch当中异常的顺序不影响异常的捕获顺序
        //try块内抛出异常后后续代码不执行
        //如果抛出的异常没有任何一个catch块可
        //以捕捉，则该异常会被抛给jvm，由jvm对该异常进行处理
        //交给jvm处理，程序就立即终止
        //try当中可能会抛出多个异常，则需要多个catch块
        //会不会同时抛出两个及以上的异常??不会，
        //exception是所有异常的父类，可以用exception接收所有的异常
        //finall  finally在写程序时，有些特定的代码，无论是否发生异常，都要执行
        //这个时候就需要finally了
        //异常处理会导致代码跳转导致一些代码不能执行

        //方法内的异常没有处理，会网上传递，查找方法的调用者，是否有对异常的处理，层层往上传递，到main方法没有处理
        //则会抛给jvm，程序终止

        try{
            int[] arr = {1,2,34};
            arr[10] = 10/0;
        }catch(ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }catch(ArithmeticException e) {
            e.printStackTrace();
        }
    }

    public static void main354(String[] args) {

    }



}